﻿#include<iostream>
using namespace std;

//class Data
//{
//public:
//	//1.无参默认构造函数
//	Data()
//	{
//		_year = 2025;
//		_mouth = 7;
//		_day = 1;
//	}
//
//	//2.含参
//	Data(int year, int mouth, int day)
//	{
//		_year = year;
//		_mouth = mouth;
//		_day = day;
//	}
//
//	//3.全缺省
//	/*Data(int year = 2025, int mouth = 7, int day = 1)
//	{
//		_year = year;
//		_mouth = mouth;
//		_day = day;
//	}*/
//
//	void print()
//	{
//		cout << _year << " " << _mouth << " " << _day << endl;
//	}
//
//
//
//private:
//	int _year;
//	int _mouth;
//	int _day;
//};
//
//
//int main()
//{
//	Data d1;
//	Data d2(2025, 7, 1);
//	Data d3;
//
//	d1.print();
//	d2.print();
//	d3.print();
//
//	return 0;
//}
//
//
//
//class Stack
//{
//public:
//	Stack(int n = 4)
//	{
//		_arr = (int*)malloc(sizeof(int) * n);
//		if (_arr == nullptr)
//		{
//			perror("开辟空间失败");
//			return;
//		}
//		capacity = n;
//		top = 0;
//	}
//	~Stack()
//	{
//		free(_arr);
//		_arr = nullptr;
//		capacity = 0;
//		top = 0;
//	}
//
//	void print()
//	{
//		cout << &_arr << " " << capacity << " " << top << endl;
//	}
//
//private:
//	int* _arr;
//	int capacity;
//	int top;
//};
//
//class myqunue
//{
//public:
//	//在自定义类型下，编译器调用了Stack的构造，完成了两个成员的初始化
//	//编译器默认⽣成myqunue的析构函数调⽤了Stack的析构，释放的Stack内部的资源
//private:
//	Stack pushst;
//	Stack popst;
//};
//
//int main()
//{
//	Stack st;
//	st.print();
//	myqunue qu;
//
//	return 0;
//}
//
//class Data
//{
//public:
//	Data(int year = 2025, int mouth = 7, int day = 1)
//	{
//		_year = 2025;
//		_mouth = 7;
//		_day = 1;
//	}
//
//	Data(const Data& da)//1.这里要用引用传参    2.加const是因为传过来的值不允许改变
//	{
//		_year = da._year;
//		_mouth = da._mouth;
//		_day = da._day;
//	}
//
//	Data(Data* d)
//	{
//		_year = d->_year;
//		_mouth = d->_mouth;
//		_day = d->_day;
//	}
//
//	void print()
//	{
//		cout << _year << "-" << _mouth << "-" << _day << endl;
//	}
//
//private:
//	int _year;
//	int _mouth;
//	int _day;
//};
//
//void func1(Data d)
//{
//	cout << &d << endl;
//	d.print();
//}
//
//Data& func2()
//{
//	Data tmp(2025, 7, 1);
//	tmp.print();
//	return tmp;
//}
//
//
//int main()
//{
//	Data d1(2025, 7, 1);
//	func1(d1);
//	cout << &d1 << endl;//深拷贝地址不同
//
//	Data d2(d1);//拷贝函数
//	d2.print();
//
//	Data d3 = d1;//拷贝函数的另一种写法
//	d3.print();
//
//	Data d4(&d1);//就是普通的构造函数
//	d4.print();
//
//	// Func2返回了⼀个局部对象tmp的引⽤作为返回值 
//    // Func2函数结束，tmp对象就销毁了，相当于了⼀个野引⽤
//	Data ret = func2();
//	ret.print();
//
//}
//
//class Stack
//	{
//	public:
//		Stack(int n = 4)
//		{
//			_arr = (int*)malloc(sizeof(int) * n);
//			if (_arr == nullptr)
//			{
//				perror("开辟空间失败");
//				return;
//			}
//			capacity = n;
//			top = 0;
//		}
//
//		Stack(const Stack& s)
//		{
//			_arr = (int*)malloc(sizeof(int) * s.capacity);//重新开辟一个空间
//			if (_arr == nullptr)
//			{
//				perror("开辟空间失败");
//				return;
//			}
//			memcpy(_arr, s._arr, sizeof(int)* s.top);
//			capacity = s.capacity;
//			top = s.top;
//		}
//
//
//		void Push(int x)
//		{
//			if (top == capacity)
//			{
//				int newcapacity = capacity * 2;
//				int* tmp = (int*)realloc(_arr, newcapacity *sizeof(int));
//				if (tmp == NULL)
//				{
//					perror("realloc fail");
//					return;
//				}
//				_arr = tmp;
//				capacity = newcapacity;
//			}
//			_arr[top++] = x;
//		}
//
//
//		~Stack()
//		{
//			free(_arr);
//			_arr = nullptr;
//			capacity = 0;
//			top = 0;
//		}
//	
//		void print()
//		{
//			cout << &_arr << " " << capacity << " " << top << endl;
//		}
//	
//	private:
//		int* _arr;
//		int capacity;
//		int top;
//	};
//	
//	class myqunue
//	{
//	public:
//		
//	private:
//		Stack pushst;
//		Stack popst;
//	};
//	
//	int main()
//	{
//		Stack st;
//		st.Push(1);
//		st.Push(2);
//		// Stack不显⽰实现拷⻉构造，⽤⾃动⽣成的拷⻉构造完成浅拷⻉ 
//        // 会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃 
//		Stack st2 = st;
//		myqunue qu;
//		myqunue qu2 = qu;//用了成员Stack的拷贝函数
//	
//		return 0;
//	}
//

//int operator+(int a, int b)
//{
//	return a - b;
//}
//
//int main()
//{
//	int a, b = 3;
//	//error C2803: “operator +”必须至少有一个类类型的形参
//	a + b;
//	return 0;
//}


//class A
//{
//public:
//	void func()
//	{
//		cout << "func" << endl;
//	}
//};
//
//typedef void(A::* pf)();//成员函数指针类型 
//
//int main()
//{
//	pf p = &A::func;// C++规定成员函数要加&才能取到函数指针 
//
//	A obj;
//	(obj.*p)();// 对象调⽤成员函数指针时，使⽤.*运算符
//
//	return 0;
//}

//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//	//private:
//	int _year;
//	int _month;
//	int _day;
//};
//// 重载为全局的⾯临对象访问私有成员变量的问题 
//// 有⼏种⽅法可以解决： 
//// 1、成员放公有  
//// 2、Date提供getxxx函数 
//// 3、友元函数 
//// 4、重载为成员函数 
//bool operator==(const Date& d1, const Date& d2)
//{
//	return d1._year == d2._year
//		&& d1._month == d2._month
//		&& d1._day == d2._day;
//}
//int main()
//{
//	Date d1(2024, 7, 5);
//	Date d2(2024, 7, 6);
//	// 运算符重载函数可以显⽰调⽤ 
//	operator==(d1, d2);
//	// 编译器会转换成 operator==(d1, d2); 
//	d1 == d2;
//	return 0;
//}


//#include<iostream>
//using namespace std;
//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//	//重载成成员函数
//	bool operator==(const Date& d)
//	{
//		return _year == d._year
//			&& _month == d._month
//			&& _day == d._day;
//	}
//	Date& operator++()
//	{
//		cout << "前置++" << endl;
//		//...
//		return *this;
//	}
//	//这返回的是临时变量不能引用返回
//	Date operator++(int)
//	{
//		Date tmp;
//		cout << "后置++" << endl;
//		//...
//		return tmp;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//int main()
//{
//	Date d1(2025, 7, 1);
//	Date d2(2025, 7, 1);
//	// 运算符重载函数可以显⽰调⽤ 
//	d1.operator == (d2);
//	// 编译器会转换成 d1.operator==(d2); 
//	d1 == d2;
//	// 编译器会转换成 d1.operator++(); 
//	++d1;
//	// 编译器会转换成 d1.operator++(0); 
//	d1++;
//	return 0;
//}


//class Data
//{
//public:
//	Data(int year = 1, int month = 1, int day = 1)
//	{
//			_year = year;
//			_mouth = month;
//			_day = day;
//	}
//
//
//
//ostream& operator<<(ostream& out)
//	{
//		out << _year << " " << _mouth << " " << _day;
//		return out;
//	}
//
//
//private:
//	int _year;
//	int _mouth;
//	int _day;
//};
//
//
//
//
//int main()
//{
//	Data d1(2025, 7, 1);
//	d1 << cout;
//}



class Data
{
public:
	Data(int year = 1, int mouth = 1, int day = 1)
	{
		_year = year;
		_mouth = mouth;
		_day = day;
	}

	Data(const Data& d)
	{
		_year = d._year;
		_mouth = d._mouth;
		_day = d._day;
	}

	Data& operator=(const Data& d)
	{
		if(this != &d)
		{
			_year = d._year;
			_mouth = d._mouth;
			_day = d._day;
		}
		return *this;
	}


private:
	int _year;
	int _mouth;
	int _day;
};

int main()
{
	Data d1(2025, 7, 1);
	Data d2(d1);//拷贝构造

	Data d3(2025, 7, 2);
	d1 = d3;//赋值运算符重载

	// 需要注意这⾥是拷⻉构造，不是赋值重载 
    // 请牢牢记住赋值重载完成两个已经存在的对象直接的拷⻉赋值 
    // ⽽拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象 
	Data d4 = d1;
}